package com.warm.pump.module.skd.dao.gen;

import java.util.List;
import java.util.Map;
import java.util.Date;
import java.math.BigDecimal;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

import com.warm.pump.frame.gen.bean.PageBean;
import com.warm.pump.frame.gen.util.TypeCast;
import com.warm.pump.frame.gen.exception.ServiceException;
import com.warm.pump.module.skd.bean.po.gen.ScheduleLog;
import com.warm.pump.module.skd.mapper.gen.ScheduleLogMapper;
import com.warm.pump.module.skd.bean.po.gen.ScheduleLogExample;

@Repository
public class ScheduleLogDao {
    // 日志对象
    private transient Log log = LogFactory.getLog(this.getClass());
    @Autowired
    private ScheduleLogMapper scheduleLogMapper;

    // 增加一个后台ScheduleLog表

    public boolean insert(ScheduleLog scheduleLog) {
        try {
            scheduleLogMapper.insert(scheduleLog);
            log.debug("后台ScheduleLog表增加成功");
            return true;
        } catch (Exception e) {
            log.debug("后台ScheduleLog表增加失败");
            throw new ServiceException("后台ScheduleLog表增加失败", e);
        }
    }
    // 增加一个后台ScheduleLog表Selective

    public boolean insertSelective(ScheduleLog scheduleLog) {
        try {
            scheduleLogMapper.insertSelective(scheduleLog);
            log.debug("后台ScheduleLog表增加成功");
            return true;
        } catch (Exception e) {
            log.debug("后台ScheduleLog表增加失败");
            throw new ServiceException("后台ScheduleLog表增加失败", e);
        }
    }

    // 删除一个后台ScheduleLog表

    public boolean deleteByPrimaryKey(Long id) {
        try {
            scheduleLogMapper.deleteByPrimaryKey(id);
            log.debug("后台ScheduleLog表删除成功");
            return true;
        } catch (Exception e) {
            log.debug("后台ScheduleLog表删除失败");
            throw new ServiceException("后台ScheduleLog表删除失败", e);
        }
    }
    // 删除一个后台ScheduleLog表byMap

    public boolean deleteByMap(Map scheduleLogMap) {
        try {
            scheduleLogMapper.deleteByExample(createScheduleLogExample(scheduleLogMap, null, null));
            log.debug("后台ScheduleLog根据Map删除成功");
            return true;
        } catch (Exception e) {
            log.debug("后台ScheduleLog根据GroupID删除失败");
            throw new ServiceException("后台ScheduleLog根据object删除失败", e);
        }
    }
    // 修改一个后台ScheduleLog表

    public boolean updateByPrimaryKey(ScheduleLog scheduleLog) {
        try {
            scheduleLogMapper.updateByPrimaryKey(scheduleLog);
            log.debug("后台ScheduleLog表修改成功");
            return true;
        } catch (Exception e) {
            log.debug("后台ScheduleLog表修改失败");
            throw new ServiceException("后台ScheduleLog表修改失败", e);
        }
    }
    // 修改一个后台ScheduleLog表Selective

    public boolean updateByPrimaryKeySelective(ScheduleLog scheduleLog) {
        try {
            scheduleLogMapper.updateByPrimaryKeySelective(scheduleLog);
            log.debug("后台ScheduleLog表修改成功");
            return true;
        } catch (Exception e) {
            log.debug("后台ScheduleLog表修改失败");
            throw new ServiceException("后台ScheduleLog表修改失败", e);
        }
    }
    // 修改一个后台ScheduleLog表

    public boolean updateByMap(ScheduleLog scheduleLog, Map scheduleLogMap) {
        try {
            scheduleLogMapper.updateByExample(scheduleLog, createScheduleLogExample(scheduleLogMap, null, null));
            log.debug("后台批量ScheduleLog表修改成功");
            return true;
        } catch (Exception e) {
            log.debug("后台批量ScheduleLog表修改失败");
            throw new ServiceException("后台ScheduleLog表批量修改失败", e);
        }
    }
    // 修改一个后台ScheduleLog表Selective

    public boolean updateByMapSelective(ScheduleLog scheduleLog, Map scheduleLogMap) {
        try {
            scheduleLogMapper.updateByExampleSelective(scheduleLog, createScheduleLogExample(scheduleLogMap, null, null));
            log.debug("后台批量ScheduleLog表修改成功");
            return true;
        } catch (Exception e) {
            log.debug("后台批量ScheduleLog表修改失败");
            throw new ServiceException("后台ScheduleLog表批量修改失败", e);
        }
    }

    // 查询一个后台ScheduleLog表

    public ScheduleLog selectByPrimaryKey(Long id) {
        return scheduleLogMapper.selectByPrimaryKey(id);
    }

    // 查询一个后台ScheduleLog表-根据map

    public ScheduleLog selectByMap(Map scheduleLogMap) {
        List<ScheduleLog> list = getListByMap(scheduleLogMap);
        if (list == null || list.isEmpty()) {
            return null;
        } else {
            return list.get(0);
        }
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    // 查询所有后台ScheduleLog表

    public List<ScheduleLog> getListByMap(Map scheduleLogMap) {

        return scheduleLogMapper.selectByExample(createScheduleLogExample(scheduleLogMap, null, null));
    }

    //统计后台ScheduleLog表数量

    public int countTotalByMap(Map scheduleLogMap) {

        return scheduleLogMapper.countByExample(createScheduleLogExample(scheduleLogMap, null, null));
    }


    public List<ScheduleLog> getListByMapPage(Map scheduleLogMap, int limitStart,
                                              int limitOffset) {

        return scheduleLogMapper.selectByExample(createScheduleLogExample(scheduleLogMap, limitStart, limitOffset));
    }


    public PageBean getPageBeanByMap(Map scheduleLogMap, int pageNo, int pageSize) {
        Integer count = countTotalByMap(scheduleLogMap);
        PageBean pageBean = new PageBean();
        pageBean.setCount(count);
        pageBean.setPageNo(pageNo);
        pageBean.setPageSize(pageSize);
        int limitStart = pageBean.getStartNo();
        int limitOffset = pageSize;
        pageBean.setData(scheduleLogMapper.selectByExample(createScheduleLogExample(scheduleLogMap, limitStart, limitOffset)));
        return pageBean;
    }

    private ScheduleLogExample createScheduleLogExample(Map scheduleLogMap, Integer limitStart, Integer limitOffset) {
        ScheduleLogExample scheduleLogEx = new ScheduleLogExample();
        ScheduleLogExample.Criteria c = scheduleLogEx.createCriteria();
        Long id_null = TypeCast.getLong(scheduleLogMap.get("id_null"));
        Long id_notNull = TypeCast.getLong(scheduleLogMap.get("id_notNull"));
        Long id = TypeCast.getLong(scheduleLogMap.get("id"));
        Long id_not = TypeCast.getLong(scheduleLogMap.get("id_not"));
        Long id_greater = TypeCast.getLong(scheduleLogMap.get("id_greater"));
        Long id_greaterEqual = TypeCast.getLong(scheduleLogMap.get("id_greaterEqual"));
        Long id_less = TypeCast.getLong(scheduleLogMap.get("id_less"));
        Long id_lessEqual = TypeCast.getLong(scheduleLogMap.get("id_lessEqual"));
        List<Long> id_in = TypeCast.getLongList(scheduleLogMap.get("id_in"));
        List<Long> id_notIn = TypeCast.getLongList(scheduleLogMap.get("id_notIn"));
        Long id_between1 = TypeCast.getLong(scheduleLogMap.get("id_between1"));
        Long id_between2 = TypeCast.getLong(scheduleLogMap.get("id_between2"));
        Long id_notBetween1 = TypeCast.getLong(scheduleLogMap.get("id_notBetween1"));
        Long id_notBetween2 = TypeCast.getLong(scheduleLogMap.get("id_notBetween2"));

        if (id_null != null) {
            c.andIdIsNull();
        }
        if (id_notNull != null) {
            c.andIdIsNotNull();
        }
        if (id != null) {
            c.andIdEqualTo(id);
        }
        if (id_not != null) {
            c.andIdNotEqualTo(id_not);
        }
        if (id_greater != null) {
            c.andIdGreaterThan(id_greater);
        }
        if (id_greaterEqual != null) {
            c.andIdGreaterThanOrEqualTo(id_greaterEqual);
        }
        if (id_less != null) {
            c.andIdLessThan(id_less);
        }
        if (id_lessEqual != null) {
            c.andIdLessThanOrEqualTo(id_lessEqual);
        }
        if (id_in != null) {
            c.andIdIn(id_in);
        }
        if (id_notIn != null) {
            c.andIdNotIn(id_notIn);
        }
        if (id_between1 != null) {
            c.andIdBetween(id_between1, id_between2);
        }
        if (id_notBetween1 != null) {
            c.andIdNotBetween(id_notBetween1, id_notBetween2);
        }
        String instanceId_null = TypeCast.getString(scheduleLogMap.get("instanceId_null"));
        String instanceId_notNull = TypeCast.getString(scheduleLogMap.get("instanceId_notNull"));
        String instanceId = TypeCast.getString(scheduleLogMap.get("instanceId"));
        String instanceId_not = TypeCast.getString(scheduleLogMap.get("instanceId_not"));
        String instanceId_greater = TypeCast.getString(scheduleLogMap.get("instanceId_greater"));
        String instanceId_greaterEqual = TypeCast.getString(scheduleLogMap.get("instanceId_greaterEqual"));
        String instanceId_less = TypeCast.getString(scheduleLogMap.get("instanceId_less"));
        String instanceId_lessEqual = TypeCast.getString(scheduleLogMap.get("instanceId_lessEqual"));
        String instanceId_like = TypeCast.getString(scheduleLogMap.get("instanceId_like"));
        String instanceId_notLike = TypeCast.getString(scheduleLogMap.get("instanceId_notLike"));
        List<String> instanceId_in = TypeCast.getStringList(scheduleLogMap.get("instanceId_in"));
        List<String> instanceId_notIn = TypeCast.getStringList(scheduleLogMap.get("instanceId_notIn"));
        String instanceId_between1 = TypeCast.getString(scheduleLogMap.get("instanceId_between1"));
        String instanceId_between2 = TypeCast.getString(scheduleLogMap.get("instanceId_between2"));
        String instanceId_notBetween1 = TypeCast.getString(scheduleLogMap.get("instanceId_notBetween1"));
        String instanceId_notBetween2 = TypeCast.getString(scheduleLogMap.get("instanceId_notBetween2"));

        if (instanceId_null != null) {
            c.andInstanceIdIsNull();
        }
        if (instanceId_notNull != null) {
            c.andInstanceIdIsNotNull();
        }
        if (instanceId != null) {
            c.andInstanceIdEqualTo(instanceId);
        }
        if (instanceId_not != null) {
            c.andInstanceIdNotEqualTo(instanceId_not);
        }
        if (instanceId_greater != null) {
            c.andInstanceIdGreaterThan(instanceId_greater);
        }
        if (instanceId_greaterEqual != null) {
            c.andInstanceIdGreaterThanOrEqualTo(instanceId_greaterEqual);
        }
        if (instanceId_less != null) {
            c.andInstanceIdLessThan(instanceId_less);
        }
        if (instanceId_lessEqual != null) {
            c.andInstanceIdLessThanOrEqualTo(instanceId_lessEqual);
        }
        if (instanceId_like != null) {
            c.andInstanceIdLike(instanceId_like);
        }
        if (instanceId_notLike != null) {
            c.andInstanceIdNotLike(instanceId_notLike);
        }
        if (instanceId_in != null) {
            c.andInstanceIdIn(instanceId_in);
        }
        if (instanceId_notIn != null) {
            c.andInstanceIdNotIn(instanceId_notIn);
        }
        if (instanceId_between1 != null) {
            c.andInstanceIdBetween(instanceId_between1, instanceId_between2);
        }
        if (instanceId_notBetween1 != null) {
            c.andInstanceIdNotBetween(instanceId_notBetween1, instanceId_notBetween2);
        }
        Long instanceDtlId_null = TypeCast.getLong(scheduleLogMap.get("instanceDtlId_null"));
        Long instanceDtlId_notNull = TypeCast.getLong(scheduleLogMap.get("instanceDtlId_notNull"));
        Long instanceDtlId = TypeCast.getLong(scheduleLogMap.get("instanceDtlId"));
        Long instanceDtlId_not = TypeCast.getLong(scheduleLogMap.get("instanceDtlId_not"));
        Long instanceDtlId_greater = TypeCast.getLong(scheduleLogMap.get("instanceDtlId_greater"));
        Long instanceDtlId_greaterEqual = TypeCast.getLong(scheduleLogMap.get("instanceDtlId_greaterEqual"));
        Long instanceDtlId_less = TypeCast.getLong(scheduleLogMap.get("instanceDtlId_less"));
        Long instanceDtlId_lessEqual = TypeCast.getLong(scheduleLogMap.get("instanceDtlId_lessEqual"));
        List<Long> instanceDtlId_in = TypeCast.getLongList(scheduleLogMap.get("instanceDtlId_in"));
        List<Long> instanceDtlId_notIn = TypeCast.getLongList(scheduleLogMap.get("instanceDtlId_notIn"));
        Long instanceDtlId_between1 = TypeCast.getLong(scheduleLogMap.get("instanceDtlId_between1"));
        Long instanceDtlId_between2 = TypeCast.getLong(scheduleLogMap.get("instanceDtlId_between2"));
        Long instanceDtlId_notBetween1 = TypeCast.getLong(scheduleLogMap.get("instanceDtlId_notBetween1"));
        Long instanceDtlId_notBetween2 = TypeCast.getLong(scheduleLogMap.get("instanceDtlId_notBetween2"));

        if (instanceDtlId_null != null) {
            c.andInstanceDtlIdIsNull();
        }
        if (instanceDtlId_notNull != null) {
            c.andInstanceDtlIdIsNotNull();
        }
        if (instanceDtlId != null) {
            c.andInstanceDtlIdEqualTo(instanceDtlId);
        }
        if (instanceDtlId_not != null) {
            c.andInstanceDtlIdNotEqualTo(instanceDtlId_not);
        }
        if (instanceDtlId_greater != null) {
            c.andInstanceDtlIdGreaterThan(instanceDtlId_greater);
        }
        if (instanceDtlId_greaterEqual != null) {
            c.andInstanceDtlIdGreaterThanOrEqualTo(instanceDtlId_greaterEqual);
        }
        if (instanceDtlId_less != null) {
            c.andInstanceDtlIdLessThan(instanceDtlId_less);
        }
        if (instanceDtlId_lessEqual != null) {
            c.andInstanceDtlIdLessThanOrEqualTo(instanceDtlId_lessEqual);
        }
        if (instanceDtlId_in != null) {
            c.andInstanceDtlIdIn(instanceDtlId_in);
        }
        if (instanceDtlId_notIn != null) {
            c.andInstanceDtlIdNotIn(instanceDtlId_notIn);
        }
        if (instanceDtlId_between1 != null) {
            c.andInstanceDtlIdBetween(instanceDtlId_between1, instanceDtlId_between2);
        }
        if (instanceDtlId_notBetween1 != null) {
            c.andInstanceDtlIdNotBetween(instanceDtlId_notBetween1, instanceDtlId_notBetween2);
        }
        Long workSubjectId_null = TypeCast.getLong(scheduleLogMap.get("workSubjectId_null"));
        Long workSubjectId_notNull = TypeCast.getLong(scheduleLogMap.get("workSubjectId_notNull"));
        Long workSubjectId = TypeCast.getLong(scheduleLogMap.get("workSubjectId"));
        Long workSubjectId_not = TypeCast.getLong(scheduleLogMap.get("workSubjectId_not"));
        Long workSubjectId_greater = TypeCast.getLong(scheduleLogMap.get("workSubjectId_greater"));
        Long workSubjectId_greaterEqual = TypeCast.getLong(scheduleLogMap.get("workSubjectId_greaterEqual"));
        Long workSubjectId_less = TypeCast.getLong(scheduleLogMap.get("workSubjectId_less"));
        Long workSubjectId_lessEqual = TypeCast.getLong(scheduleLogMap.get("workSubjectId_lessEqual"));
        List<Long> workSubjectId_in = TypeCast.getLongList(scheduleLogMap.get("workSubjectId_in"));
        List<Long> workSubjectId_notIn = TypeCast.getLongList(scheduleLogMap.get("workSubjectId_notIn"));
        Long workSubjectId_between1 = TypeCast.getLong(scheduleLogMap.get("workSubjectId_between1"));
        Long workSubjectId_between2 = TypeCast.getLong(scheduleLogMap.get("workSubjectId_between2"));
        Long workSubjectId_notBetween1 = TypeCast.getLong(scheduleLogMap.get("workSubjectId_notBetween1"));
        Long workSubjectId_notBetween2 = TypeCast.getLong(scheduleLogMap.get("workSubjectId_notBetween2"));

        if (workSubjectId_null != null) {
            c.andWorkSubjectIdIsNull();
        }
        if (workSubjectId_notNull != null) {
            c.andWorkSubjectIdIsNotNull();
        }
        if (workSubjectId != null) {
            c.andWorkSubjectIdEqualTo(workSubjectId);
        }
        if (workSubjectId_not != null) {
            c.andWorkSubjectIdNotEqualTo(workSubjectId_not);
        }
        if (workSubjectId_greater != null) {
            c.andWorkSubjectIdGreaterThan(workSubjectId_greater);
        }
        if (workSubjectId_greaterEqual != null) {
            c.andWorkSubjectIdGreaterThanOrEqualTo(workSubjectId_greaterEqual);
        }
        if (workSubjectId_less != null) {
            c.andWorkSubjectIdLessThan(workSubjectId_less);
        }
        if (workSubjectId_lessEqual != null) {
            c.andWorkSubjectIdLessThanOrEqualTo(workSubjectId_lessEqual);
        }
        if (workSubjectId_in != null) {
            c.andWorkSubjectIdIn(workSubjectId_in);
        }
        if (workSubjectId_notIn != null) {
            c.andWorkSubjectIdNotIn(workSubjectId_notIn);
        }
        if (workSubjectId_between1 != null) {
            c.andWorkSubjectIdBetween(workSubjectId_between1, workSubjectId_between2);
        }
        if (workSubjectId_notBetween1 != null) {
            c.andWorkSubjectIdNotBetween(workSubjectId_notBetween1, workSubjectId_notBetween2);
        }
        String workSubjectName_null = TypeCast.getString(scheduleLogMap.get("workSubjectName_null"));
        String workSubjectName_notNull = TypeCast.getString(scheduleLogMap.get("workSubjectName_notNull"));
        String workSubjectName = TypeCast.getString(scheduleLogMap.get("workSubjectName"));
        String workSubjectName_not = TypeCast.getString(scheduleLogMap.get("workSubjectName_not"));
        String workSubjectName_greater = TypeCast.getString(scheduleLogMap.get("workSubjectName_greater"));
        String workSubjectName_greaterEqual = TypeCast.getString(scheduleLogMap.get("workSubjectName_greaterEqual"));
        String workSubjectName_less = TypeCast.getString(scheduleLogMap.get("workSubjectName_less"));
        String workSubjectName_lessEqual = TypeCast.getString(scheduleLogMap.get("workSubjectName_lessEqual"));
        String workSubjectName_like = TypeCast.getString(scheduleLogMap.get("workSubjectName_like"));
        String workSubjectName_notLike = TypeCast.getString(scheduleLogMap.get("workSubjectName_notLike"));
        List<String> workSubjectName_in = TypeCast.getStringList(scheduleLogMap.get("workSubjectName_in"));
        List<String> workSubjectName_notIn = TypeCast.getStringList(scheduleLogMap.get("workSubjectName_notIn"));
        String workSubjectName_between1 = TypeCast.getString(scheduleLogMap.get("workSubjectName_between1"));
        String workSubjectName_between2 = TypeCast.getString(scheduleLogMap.get("workSubjectName_between2"));
        String workSubjectName_notBetween1 = TypeCast.getString(scheduleLogMap.get("workSubjectName_notBetween1"));
        String workSubjectName_notBetween2 = TypeCast.getString(scheduleLogMap.get("workSubjectName_notBetween2"));

        if (workSubjectName_null != null) {
            c.andWorkSubjectNameIsNull();
        }
        if (workSubjectName_notNull != null) {
            c.andWorkSubjectNameIsNotNull();
        }
        if (workSubjectName != null) {
            c.andWorkSubjectNameEqualTo(workSubjectName);
        }
        if (workSubjectName_not != null) {
            c.andWorkSubjectNameNotEqualTo(workSubjectName_not);
        }
        if (workSubjectName_greater != null) {
            c.andWorkSubjectNameGreaterThan(workSubjectName_greater);
        }
        if (workSubjectName_greaterEqual != null) {
            c.andWorkSubjectNameGreaterThanOrEqualTo(workSubjectName_greaterEqual);
        }
        if (workSubjectName_less != null) {
            c.andWorkSubjectNameLessThan(workSubjectName_less);
        }
        if (workSubjectName_lessEqual != null) {
            c.andWorkSubjectNameLessThanOrEqualTo(workSubjectName_lessEqual);
        }
        if (workSubjectName_like != null) {
            c.andWorkSubjectNameLike(workSubjectName_like);
        }
        if (workSubjectName_notLike != null) {
            c.andWorkSubjectNameNotLike(workSubjectName_notLike);
        }
        if (workSubjectName_in != null) {
            c.andWorkSubjectNameIn(workSubjectName_in);
        }
        if (workSubjectName_notIn != null) {
            c.andWorkSubjectNameNotIn(workSubjectName_notIn);
        }
        if (workSubjectName_between1 != null) {
            c.andWorkSubjectNameBetween(workSubjectName_between1, workSubjectName_between2);
        }
        if (workSubjectName_notBetween1 != null) {
            c.andWorkSubjectNameNotBetween(workSubjectName_notBetween1, workSubjectName_notBetween2);
        }
        Long workId_null = TypeCast.getLong(scheduleLogMap.get("workId_null"));
        Long workId_notNull = TypeCast.getLong(scheduleLogMap.get("workId_notNull"));
        Long workId = TypeCast.getLong(scheduleLogMap.get("workId"));
        Long workId_not = TypeCast.getLong(scheduleLogMap.get("workId_not"));
        Long workId_greater = TypeCast.getLong(scheduleLogMap.get("workId_greater"));
        Long workId_greaterEqual = TypeCast.getLong(scheduleLogMap.get("workId_greaterEqual"));
        Long workId_less = TypeCast.getLong(scheduleLogMap.get("workId_less"));
        Long workId_lessEqual = TypeCast.getLong(scheduleLogMap.get("workId_lessEqual"));
        List<Long> workId_in = TypeCast.getLongList(scheduleLogMap.get("workId_in"));
        List<Long> workId_notIn = TypeCast.getLongList(scheduleLogMap.get("workId_notIn"));
        Long workId_between1 = TypeCast.getLong(scheduleLogMap.get("workId_between1"));
        Long workId_between2 = TypeCast.getLong(scheduleLogMap.get("workId_between2"));
        Long workId_notBetween1 = TypeCast.getLong(scheduleLogMap.get("workId_notBetween1"));
        Long workId_notBetween2 = TypeCast.getLong(scheduleLogMap.get("workId_notBetween2"));

        if (workId_null != null) {
            c.andWorkIdIsNull();
        }
        if (workId_notNull != null) {
            c.andWorkIdIsNotNull();
        }
        if (workId != null) {
            c.andWorkIdEqualTo(workId);
        }
        if (workId_not != null) {
            c.andWorkIdNotEqualTo(workId_not);
        }
        if (workId_greater != null) {
            c.andWorkIdGreaterThan(workId_greater);
        }
        if (workId_greaterEqual != null) {
            c.andWorkIdGreaterThanOrEqualTo(workId_greaterEqual);
        }
        if (workId_less != null) {
            c.andWorkIdLessThan(workId_less);
        }
        if (workId_lessEqual != null) {
            c.andWorkIdLessThanOrEqualTo(workId_lessEqual);
        }
        if (workId_in != null) {
            c.andWorkIdIn(workId_in);
        }
        if (workId_notIn != null) {
            c.andWorkIdNotIn(workId_notIn);
        }
        if (workId_between1 != null) {
            c.andWorkIdBetween(workId_between1, workId_between2);
        }
        if (workId_notBetween1 != null) {
            c.andWorkIdNotBetween(workId_notBetween1, workId_notBetween2);
        }
        String workName_null = TypeCast.getString(scheduleLogMap.get("workName_null"));
        String workName_notNull = TypeCast.getString(scheduleLogMap.get("workName_notNull"));
        String workName = TypeCast.getString(scheduleLogMap.get("workName"));
        String workName_not = TypeCast.getString(scheduleLogMap.get("workName_not"));
        String workName_greater = TypeCast.getString(scheduleLogMap.get("workName_greater"));
        String workName_greaterEqual = TypeCast.getString(scheduleLogMap.get("workName_greaterEqual"));
        String workName_less = TypeCast.getString(scheduleLogMap.get("workName_less"));
        String workName_lessEqual = TypeCast.getString(scheduleLogMap.get("workName_lessEqual"));
        String workName_like = TypeCast.getString(scheduleLogMap.get("workName_like"));
        String workName_notLike = TypeCast.getString(scheduleLogMap.get("workName_notLike"));
        List<String> workName_in = TypeCast.getStringList(scheduleLogMap.get("workName_in"));
        List<String> workName_notIn = TypeCast.getStringList(scheduleLogMap.get("workName_notIn"));
        String workName_between1 = TypeCast.getString(scheduleLogMap.get("workName_between1"));
        String workName_between2 = TypeCast.getString(scheduleLogMap.get("workName_between2"));
        String workName_notBetween1 = TypeCast.getString(scheduleLogMap.get("workName_notBetween1"));
        String workName_notBetween2 = TypeCast.getString(scheduleLogMap.get("workName_notBetween2"));

        if (workName_null != null) {
            c.andWorkNameIsNull();
        }
        if (workName_notNull != null) {
            c.andWorkNameIsNotNull();
        }
        if (workName != null) {
            c.andWorkNameEqualTo(workName);
        }
        if (workName_not != null) {
            c.andWorkNameNotEqualTo(workName_not);
        }
        if (workName_greater != null) {
            c.andWorkNameGreaterThan(workName_greater);
        }
        if (workName_greaterEqual != null) {
            c.andWorkNameGreaterThanOrEqualTo(workName_greaterEqual);
        }
        if (workName_less != null) {
            c.andWorkNameLessThan(workName_less);
        }
        if (workName_lessEqual != null) {
            c.andWorkNameLessThanOrEqualTo(workName_lessEqual);
        }
        if (workName_like != null) {
            c.andWorkNameLike(workName_like);
        }
        if (workName_notLike != null) {
            c.andWorkNameNotLike(workName_notLike);
        }
        if (workName_in != null) {
            c.andWorkNameIn(workName_in);
        }
        if (workName_notIn != null) {
            c.andWorkNameNotIn(workName_notIn);
        }
        if (workName_between1 != null) {
            c.andWorkNameBetween(workName_between1, workName_between2);
        }
        if (workName_notBetween1 != null) {
            c.andWorkNameNotBetween(workName_notBetween1, workName_notBetween2);
        }
        Integer workLevelNum_null = TypeCast.getInteger(scheduleLogMap.get("workLevelNum_null"));
        Integer workLevelNum_notNull = TypeCast.getInteger(scheduleLogMap.get("workLevelNum_notNull"));
        Integer workLevelNum = TypeCast.getInteger(scheduleLogMap.get("workLevelNum"));
        Integer workLevelNum_not = TypeCast.getInteger(scheduleLogMap.get("workLevelNum_not"));
        Integer workLevelNum_greater = TypeCast.getInteger(scheduleLogMap.get("workLevelNum_greater"));
        Integer workLevelNum_greaterEqual = TypeCast.getInteger(scheduleLogMap.get("workLevelNum_greaterEqual"));
        Integer workLevelNum_less = TypeCast.getInteger(scheduleLogMap.get("workLevelNum_less"));
        Integer workLevelNum_lessEqual = TypeCast.getInteger(scheduleLogMap.get("workLevelNum_lessEqual"));
        List<Integer> workLevelNum_in = TypeCast.getIntegerList(scheduleLogMap.get("workLevelNum_in"));
        List<Integer> workLevelNum_notIn = TypeCast.getIntegerList(scheduleLogMap.get("workLevelNum_notIn"));
        Integer workLevelNum_between1 = TypeCast.getInteger(scheduleLogMap.get("workLevelNum_between1"));
        Integer workLevelNum_between2 = TypeCast.getInteger(scheduleLogMap.get("workLevelNum_between2"));
        Integer workLevelNum_notBetween1 = TypeCast.getInteger(scheduleLogMap.get("workLevelNum_notBetween1"));
        Integer workLevelNum_notBetween2 = TypeCast.getInteger(scheduleLogMap.get("workLevelNum_notBetween2"));

        if (workLevelNum_null != null) {
            c.andWorkLevelNumIsNull();
        }
        if (workLevelNum_notNull != null) {
            c.andWorkLevelNumIsNotNull();
        }
        if (workLevelNum != null) {
            c.andWorkLevelNumEqualTo(workLevelNum);
        }
        if (workLevelNum_not != null) {
            c.andWorkLevelNumNotEqualTo(workLevelNum_not);
        }
        if (workLevelNum_greater != null) {
            c.andWorkLevelNumGreaterThan(workLevelNum_greater);
        }
        if (workLevelNum_greaterEqual != null) {
            c.andWorkLevelNumGreaterThanOrEqualTo(workLevelNum_greaterEqual);
        }
        if (workLevelNum_less != null) {
            c.andWorkLevelNumLessThan(workLevelNum_less);
        }
        if (workLevelNum_lessEqual != null) {
            c.andWorkLevelNumLessThanOrEqualTo(workLevelNum_lessEqual);
        }
        if (workLevelNum_in != null) {
            c.andWorkLevelNumIn(workLevelNum_in);
        }
        if (workLevelNum_notIn != null) {
            c.andWorkLevelNumNotIn(workLevelNum_notIn);
        }
        if (workLevelNum_between1 != null) {
            c.andWorkLevelNumBetween(workLevelNum_between1, workLevelNum_between2);
        }
        if (workLevelNum_notBetween1 != null) {
            c.andWorkLevelNumNotBetween(workLevelNum_notBetween1, workLevelNum_notBetween2);
        }
        Long workItemId_null = TypeCast.getLong(scheduleLogMap.get("workItemId_null"));
        Long workItemId_notNull = TypeCast.getLong(scheduleLogMap.get("workItemId_notNull"));
        Long workItemId = TypeCast.getLong(scheduleLogMap.get("workItemId"));
        Long workItemId_not = TypeCast.getLong(scheduleLogMap.get("workItemId_not"));
        Long workItemId_greater = TypeCast.getLong(scheduleLogMap.get("workItemId_greater"));
        Long workItemId_greaterEqual = TypeCast.getLong(scheduleLogMap.get("workItemId_greaterEqual"));
        Long workItemId_less = TypeCast.getLong(scheduleLogMap.get("workItemId_less"));
        Long workItemId_lessEqual = TypeCast.getLong(scheduleLogMap.get("workItemId_lessEqual"));
        List<Long> workItemId_in = TypeCast.getLongList(scheduleLogMap.get("workItemId_in"));
        List<Long> workItemId_notIn = TypeCast.getLongList(scheduleLogMap.get("workItemId_notIn"));
        Long workItemId_between1 = TypeCast.getLong(scheduleLogMap.get("workItemId_between1"));
        Long workItemId_between2 = TypeCast.getLong(scheduleLogMap.get("workItemId_between2"));
        Long workItemId_notBetween1 = TypeCast.getLong(scheduleLogMap.get("workItemId_notBetween1"));
        Long workItemId_notBetween2 = TypeCast.getLong(scheduleLogMap.get("workItemId_notBetween2"));

        if (workItemId_null != null) {
            c.andWorkItemIdIsNull();
        }
        if (workItemId_notNull != null) {
            c.andWorkItemIdIsNotNull();
        }
        if (workItemId != null) {
            c.andWorkItemIdEqualTo(workItemId);
        }
        if (workItemId_not != null) {
            c.andWorkItemIdNotEqualTo(workItemId_not);
        }
        if (workItemId_greater != null) {
            c.andWorkItemIdGreaterThan(workItemId_greater);
        }
        if (workItemId_greaterEqual != null) {
            c.andWorkItemIdGreaterThanOrEqualTo(workItemId_greaterEqual);
        }
        if (workItemId_less != null) {
            c.andWorkItemIdLessThan(workItemId_less);
        }
        if (workItemId_lessEqual != null) {
            c.andWorkItemIdLessThanOrEqualTo(workItemId_lessEqual);
        }
        if (workItemId_in != null) {
            c.andWorkItemIdIn(workItemId_in);
        }
        if (workItemId_notIn != null) {
            c.andWorkItemIdNotIn(workItemId_notIn);
        }
        if (workItemId_between1 != null) {
            c.andWorkItemIdBetween(workItemId_between1, workItemId_between2);
        }
        if (workItemId_notBetween1 != null) {
            c.andWorkItemIdNotBetween(workItemId_notBetween1, workItemId_notBetween2);
        }
        String workItemName_null = TypeCast.getString(scheduleLogMap.get("workItemName_null"));
        String workItemName_notNull = TypeCast.getString(scheduleLogMap.get("workItemName_notNull"));
        String workItemName = TypeCast.getString(scheduleLogMap.get("workItemName"));
        String workItemName_not = TypeCast.getString(scheduleLogMap.get("workItemName_not"));
        String workItemName_greater = TypeCast.getString(scheduleLogMap.get("workItemName_greater"));
        String workItemName_greaterEqual = TypeCast.getString(scheduleLogMap.get("workItemName_greaterEqual"));
        String workItemName_less = TypeCast.getString(scheduleLogMap.get("workItemName_less"));
        String workItemName_lessEqual = TypeCast.getString(scheduleLogMap.get("workItemName_lessEqual"));
        String workItemName_like = TypeCast.getString(scheduleLogMap.get("workItemName_like"));
        String workItemName_notLike = TypeCast.getString(scheduleLogMap.get("workItemName_notLike"));
        List<String> workItemName_in = TypeCast.getStringList(scheduleLogMap.get("workItemName_in"));
        List<String> workItemName_notIn = TypeCast.getStringList(scheduleLogMap.get("workItemName_notIn"));
        String workItemName_between1 = TypeCast.getString(scheduleLogMap.get("workItemName_between1"));
        String workItemName_between2 = TypeCast.getString(scheduleLogMap.get("workItemName_between2"));
        String workItemName_notBetween1 = TypeCast.getString(scheduleLogMap.get("workItemName_notBetween1"));
        String workItemName_notBetween2 = TypeCast.getString(scheduleLogMap.get("workItemName_notBetween2"));

        if (workItemName_null != null) {
            c.andWorkItemNameIsNull();
        }
        if (workItemName_notNull != null) {
            c.andWorkItemNameIsNotNull();
        }
        if (workItemName != null) {
            c.andWorkItemNameEqualTo(workItemName);
        }
        if (workItemName_not != null) {
            c.andWorkItemNameNotEqualTo(workItemName_not);
        }
        if (workItemName_greater != null) {
            c.andWorkItemNameGreaterThan(workItemName_greater);
        }
        if (workItemName_greaterEqual != null) {
            c.andWorkItemNameGreaterThanOrEqualTo(workItemName_greaterEqual);
        }
        if (workItemName_less != null) {
            c.andWorkItemNameLessThan(workItemName_less);
        }
        if (workItemName_lessEqual != null) {
            c.andWorkItemNameLessThanOrEqualTo(workItemName_lessEqual);
        }
        if (workItemName_like != null) {
            c.andWorkItemNameLike(workItemName_like);
        }
        if (workItemName_notLike != null) {
            c.andWorkItemNameNotLike(workItemName_notLike);
        }
        if (workItemName_in != null) {
            c.andWorkItemNameIn(workItemName_in);
        }
        if (workItemName_notIn != null) {
            c.andWorkItemNameNotIn(workItemName_notIn);
        }
        if (workItemName_between1 != null) {
            c.andWorkItemNameBetween(workItemName_between1, workItemName_between2);
        }
        if (workItemName_notBetween1 != null) {
            c.andWorkItemNameNotBetween(workItemName_notBetween1, workItemName_notBetween2);
        }
        Long batchJobId_null = TypeCast.getLong(scheduleLogMap.get("batchJobId_null"));
        Long batchJobId_notNull = TypeCast.getLong(scheduleLogMap.get("batchJobId_notNull"));
        Long batchJobId = TypeCast.getLong(scheduleLogMap.get("batchJobId"));
        Long batchJobId_not = TypeCast.getLong(scheduleLogMap.get("batchJobId_not"));
        Long batchJobId_greater = TypeCast.getLong(scheduleLogMap.get("batchJobId_greater"));
        Long batchJobId_greaterEqual = TypeCast.getLong(scheduleLogMap.get("batchJobId_greaterEqual"));
        Long batchJobId_less = TypeCast.getLong(scheduleLogMap.get("batchJobId_less"));
        Long batchJobId_lessEqual = TypeCast.getLong(scheduleLogMap.get("batchJobId_lessEqual"));
        List<Long> batchJobId_in = TypeCast.getLongList(scheduleLogMap.get("batchJobId_in"));
        List<Long> batchJobId_notIn = TypeCast.getLongList(scheduleLogMap.get("batchJobId_notIn"));
        Long batchJobId_between1 = TypeCast.getLong(scheduleLogMap.get("batchJobId_between1"));
        Long batchJobId_between2 = TypeCast.getLong(scheduleLogMap.get("batchJobId_between2"));
        Long batchJobId_notBetween1 = TypeCast.getLong(scheduleLogMap.get("batchJobId_notBetween1"));
        Long batchJobId_notBetween2 = TypeCast.getLong(scheduleLogMap.get("batchJobId_notBetween2"));

        if (batchJobId_null != null) {
            c.andBatchJobIdIsNull();
        }
        if (batchJobId_notNull != null) {
            c.andBatchJobIdIsNotNull();
        }
        if (batchJobId != null) {
            c.andBatchJobIdEqualTo(batchJobId);
        }
        if (batchJobId_not != null) {
            c.andBatchJobIdNotEqualTo(batchJobId_not);
        }
        if (batchJobId_greater != null) {
            c.andBatchJobIdGreaterThan(batchJobId_greater);
        }
        if (batchJobId_greaterEqual != null) {
            c.andBatchJobIdGreaterThanOrEqualTo(batchJobId_greaterEqual);
        }
        if (batchJobId_less != null) {
            c.andBatchJobIdLessThan(batchJobId_less);
        }
        if (batchJobId_lessEqual != null) {
            c.andBatchJobIdLessThanOrEqualTo(batchJobId_lessEqual);
        }
        if (batchJobId_in != null) {
            c.andBatchJobIdIn(batchJobId_in);
        }
        if (batchJobId_notIn != null) {
            c.andBatchJobIdNotIn(batchJobId_notIn);
        }
        if (batchJobId_between1 != null) {
            c.andBatchJobIdBetween(batchJobId_between1, batchJobId_between2);
        }
        if (batchJobId_notBetween1 != null) {
            c.andBatchJobIdNotBetween(batchJobId_notBetween1, batchJobId_notBetween2);
        }
        Long batchJobInstId_null = TypeCast.getLong(scheduleLogMap.get("batchJobInstId_null"));
        Long batchJobInstId_notNull = TypeCast.getLong(scheduleLogMap.get("batchJobInstId_notNull"));
        Long batchJobInstId = TypeCast.getLong(scheduleLogMap.get("batchJobInstId"));
        Long batchJobInstId_not = TypeCast.getLong(scheduleLogMap.get("batchJobInstId_not"));
        Long batchJobInstId_greater = TypeCast.getLong(scheduleLogMap.get("batchJobInstId_greater"));
        Long batchJobInstId_greaterEqual = TypeCast.getLong(scheduleLogMap.get("batchJobInstId_greaterEqual"));
        Long batchJobInstId_less = TypeCast.getLong(scheduleLogMap.get("batchJobInstId_less"));
        Long batchJobInstId_lessEqual = TypeCast.getLong(scheduleLogMap.get("batchJobInstId_lessEqual"));
        List<Long> batchJobInstId_in = TypeCast.getLongList(scheduleLogMap.get("batchJobInstId_in"));
        List<Long> batchJobInstId_notIn = TypeCast.getLongList(scheduleLogMap.get("batchJobInstId_notIn"));
        Long batchJobInstId_between1 = TypeCast.getLong(scheduleLogMap.get("batchJobInstId_between1"));
        Long batchJobInstId_between2 = TypeCast.getLong(scheduleLogMap.get("batchJobInstId_between2"));
        Long batchJobInstId_notBetween1 = TypeCast.getLong(scheduleLogMap.get("batchJobInstId_notBetween1"));
        Long batchJobInstId_notBetween2 = TypeCast.getLong(scheduleLogMap.get("batchJobInstId_notBetween2"));

        if (batchJobInstId_null != null) {
            c.andBatchJobInstIdIsNull();
        }
        if (batchJobInstId_notNull != null) {
            c.andBatchJobInstIdIsNotNull();
        }
        if (batchJobInstId != null) {
            c.andBatchJobInstIdEqualTo(batchJobInstId);
        }
        if (batchJobInstId_not != null) {
            c.andBatchJobInstIdNotEqualTo(batchJobInstId_not);
        }
        if (batchJobInstId_greater != null) {
            c.andBatchJobInstIdGreaterThan(batchJobInstId_greater);
        }
        if (batchJobInstId_greaterEqual != null) {
            c.andBatchJobInstIdGreaterThanOrEqualTo(batchJobInstId_greaterEqual);
        }
        if (batchJobInstId_less != null) {
            c.andBatchJobInstIdLessThan(batchJobInstId_less);
        }
        if (batchJobInstId_lessEqual != null) {
            c.andBatchJobInstIdLessThanOrEqualTo(batchJobInstId_lessEqual);
        }
        if (batchJobInstId_in != null) {
            c.andBatchJobInstIdIn(batchJobInstId_in);
        }
        if (batchJobInstId_notIn != null) {
            c.andBatchJobInstIdNotIn(batchJobInstId_notIn);
        }
        if (batchJobInstId_between1 != null) {
            c.andBatchJobInstIdBetween(batchJobInstId_between1, batchJobInstId_between2);
        }
        if (batchJobInstId_notBetween1 != null) {
            c.andBatchJobInstIdNotBetween(batchJobInstId_notBetween1, batchJobInstId_notBetween2);
        }
        Integer status_null = TypeCast.getInteger(scheduleLogMap.get("status_null"));
        Integer status_notNull = TypeCast.getInteger(scheduleLogMap.get("status_notNull"));
        Integer status = TypeCast.getInteger(scheduleLogMap.get("status"));
        Integer status_not = TypeCast.getInteger(scheduleLogMap.get("status_not"));
        Integer status_greater = TypeCast.getInteger(scheduleLogMap.get("status_greater"));
        Integer status_greaterEqual = TypeCast.getInteger(scheduleLogMap.get("status_greaterEqual"));
        Integer status_less = TypeCast.getInteger(scheduleLogMap.get("status_less"));
        Integer status_lessEqual = TypeCast.getInteger(scheduleLogMap.get("status_lessEqual"));
        List<Integer> status_in = TypeCast.getIntegerList(scheduleLogMap.get("status_in"));
        List<Integer> status_notIn = TypeCast.getIntegerList(scheduleLogMap.get("status_notIn"));
        Integer status_between1 = TypeCast.getInteger(scheduleLogMap.get("status_between1"));
        Integer status_between2 = TypeCast.getInteger(scheduleLogMap.get("status_between2"));
        Integer status_notBetween1 = TypeCast.getInteger(scheduleLogMap.get("status_notBetween1"));
        Integer status_notBetween2 = TypeCast.getInteger(scheduleLogMap.get("status_notBetween2"));

        if (status_null != null) {
            c.andStatusIsNull();
        }
        if (status_notNull != null) {
            c.andStatusIsNotNull();
        }
        if (status != null) {
            c.andStatusEqualTo(status);
        }
        if (status_not != null) {
            c.andStatusNotEqualTo(status_not);
        }
        if (status_greater != null) {
            c.andStatusGreaterThan(status_greater);
        }
        if (status_greaterEqual != null) {
            c.andStatusGreaterThanOrEqualTo(status_greaterEqual);
        }
        if (status_less != null) {
            c.andStatusLessThan(status_less);
        }
        if (status_lessEqual != null) {
            c.andStatusLessThanOrEqualTo(status_lessEqual);
        }
        if (status_in != null) {
            c.andStatusIn(status_in);
        }
        if (status_notIn != null) {
            c.andStatusNotIn(status_notIn);
        }
        if (status_between1 != null) {
            c.andStatusBetween(status_between1, status_between2);
        }
        if (status_notBetween1 != null) {
            c.andStatusNotBetween(status_notBetween1, status_notBetween2);
        }
        String remark_null = TypeCast.getString(scheduleLogMap.get("remark_null"));
        String remark_notNull = TypeCast.getString(scheduleLogMap.get("remark_notNull"));
        String remark = TypeCast.getString(scheduleLogMap.get("remark"));
        String remark_not = TypeCast.getString(scheduleLogMap.get("remark_not"));
        String remark_greater = TypeCast.getString(scheduleLogMap.get("remark_greater"));
        String remark_greaterEqual = TypeCast.getString(scheduleLogMap.get("remark_greaterEqual"));
        String remark_less = TypeCast.getString(scheduleLogMap.get("remark_less"));
        String remark_lessEqual = TypeCast.getString(scheduleLogMap.get("remark_lessEqual"));
        String remark_like = TypeCast.getString(scheduleLogMap.get("remark_like"));
        String remark_notLike = TypeCast.getString(scheduleLogMap.get("remark_notLike"));
        List<String> remark_in = TypeCast.getStringList(scheduleLogMap.get("remark_in"));
        List<String> remark_notIn = TypeCast.getStringList(scheduleLogMap.get("remark_notIn"));
        String remark_between1 = TypeCast.getString(scheduleLogMap.get("remark_between1"));
        String remark_between2 = TypeCast.getString(scheduleLogMap.get("remark_between2"));
        String remark_notBetween1 = TypeCast.getString(scheduleLogMap.get("remark_notBetween1"));
        String remark_notBetween2 = TypeCast.getString(scheduleLogMap.get("remark_notBetween2"));

        if (remark_null != null) {
            c.andRemarkIsNull();
        }
        if (remark_notNull != null) {
            c.andRemarkIsNotNull();
        }
        if (remark != null) {
            c.andRemarkEqualTo(remark);
        }
        if (remark_not != null) {
            c.andRemarkNotEqualTo(remark_not);
        }
        if (remark_greater != null) {
            c.andRemarkGreaterThan(remark_greater);
        }
        if (remark_greaterEqual != null) {
            c.andRemarkGreaterThanOrEqualTo(remark_greaterEqual);
        }
        if (remark_less != null) {
            c.andRemarkLessThan(remark_less);
        }
        if (remark_lessEqual != null) {
            c.andRemarkLessThanOrEqualTo(remark_lessEqual);
        }
        if (remark_like != null) {
            c.andRemarkLike(remark_like);
        }
        if (remark_notLike != null) {
            c.andRemarkNotLike(remark_notLike);
        }
        if (remark_in != null) {
            c.andRemarkIn(remark_in);
        }
        if (remark_notIn != null) {
            c.andRemarkNotIn(remark_notIn);
        }
        if (remark_between1 != null) {
            c.andRemarkBetween(remark_between1, remark_between2);
        }
        if (remark_notBetween1 != null) {
            c.andRemarkNotBetween(remark_notBetween1, remark_notBetween2);
        }
        String error_null = TypeCast.getString(scheduleLogMap.get("error_null"));
        String error_notNull = TypeCast.getString(scheduleLogMap.get("error_notNull"));
        String error = TypeCast.getString(scheduleLogMap.get("error"));
        String error_not = TypeCast.getString(scheduleLogMap.get("error_not"));
        String error_greater = TypeCast.getString(scheduleLogMap.get("error_greater"));
        String error_greaterEqual = TypeCast.getString(scheduleLogMap.get("error_greaterEqual"));
        String error_less = TypeCast.getString(scheduleLogMap.get("error_less"));
        String error_lessEqual = TypeCast.getString(scheduleLogMap.get("error_lessEqual"));
        String error_like = TypeCast.getString(scheduleLogMap.get("error_like"));
        String error_notLike = TypeCast.getString(scheduleLogMap.get("error_notLike"));
        List<String> error_in = TypeCast.getStringList(scheduleLogMap.get("error_in"));
        List<String> error_notIn = TypeCast.getStringList(scheduleLogMap.get("error_notIn"));
        String error_between1 = TypeCast.getString(scheduleLogMap.get("error_between1"));
        String error_between2 = TypeCast.getString(scheduleLogMap.get("error_between2"));
        String error_notBetween1 = TypeCast.getString(scheduleLogMap.get("error_notBetween1"));
        String error_notBetween2 = TypeCast.getString(scheduleLogMap.get("error_notBetween2"));

        if (error_null != null) {
            c.andErrorIsNull();
        }
        if (error_notNull != null) {
            c.andErrorIsNotNull();
        }
        if (error != null) {
            c.andErrorEqualTo(error);
        }
        if (error_not != null) {
            c.andErrorNotEqualTo(error_not);
        }
        if (error_greater != null) {
            c.andErrorGreaterThan(error_greater);
        }
        if (error_greaterEqual != null) {
            c.andErrorGreaterThanOrEqualTo(error_greaterEqual);
        }
        if (error_less != null) {
            c.andErrorLessThan(error_less);
        }
        if (error_lessEqual != null) {
            c.andErrorLessThanOrEqualTo(error_lessEqual);
        }
        if (error_like != null) {
            c.andErrorLike(error_like);
        }
        if (error_notLike != null) {
            c.andErrorNotLike(error_notLike);
        }
        if (error_in != null) {
            c.andErrorIn(error_in);
        }
        if (error_notIn != null) {
            c.andErrorNotIn(error_notIn);
        }
        if (error_between1 != null) {
            c.andErrorBetween(error_between1, error_between2);
        }
        if (error_notBetween1 != null) {
            c.andErrorNotBetween(error_notBetween1, error_notBetween2);
        }
        Integer dealCnt_null = TypeCast.getInteger(scheduleLogMap.get("dealCnt_null"));
        Integer dealCnt_notNull = TypeCast.getInteger(scheduleLogMap.get("dealCnt_notNull"));
        Integer dealCnt = TypeCast.getInteger(scheduleLogMap.get("dealCnt"));
        Integer dealCnt_not = TypeCast.getInteger(scheduleLogMap.get("dealCnt_not"));
        Integer dealCnt_greater = TypeCast.getInteger(scheduleLogMap.get("dealCnt_greater"));
        Integer dealCnt_greaterEqual = TypeCast.getInteger(scheduleLogMap.get("dealCnt_greaterEqual"));
        Integer dealCnt_less = TypeCast.getInteger(scheduleLogMap.get("dealCnt_less"));
        Integer dealCnt_lessEqual = TypeCast.getInteger(scheduleLogMap.get("dealCnt_lessEqual"));
        List<Integer> dealCnt_in = TypeCast.getIntegerList(scheduleLogMap.get("dealCnt_in"));
        List<Integer> dealCnt_notIn = TypeCast.getIntegerList(scheduleLogMap.get("dealCnt_notIn"));
        Integer dealCnt_between1 = TypeCast.getInteger(scheduleLogMap.get("dealCnt_between1"));
        Integer dealCnt_between2 = TypeCast.getInteger(scheduleLogMap.get("dealCnt_between2"));
        Integer dealCnt_notBetween1 = TypeCast.getInteger(scheduleLogMap.get("dealCnt_notBetween1"));
        Integer dealCnt_notBetween2 = TypeCast.getInteger(scheduleLogMap.get("dealCnt_notBetween2"));

        if (dealCnt_null != null) {
            c.andDealCntIsNull();
        }
        if (dealCnt_notNull != null) {
            c.andDealCntIsNotNull();
        }
        if (dealCnt != null) {
            c.andDealCntEqualTo(dealCnt);
        }
        if (dealCnt_not != null) {
            c.andDealCntNotEqualTo(dealCnt_not);
        }
        if (dealCnt_greater != null) {
            c.andDealCntGreaterThan(dealCnt_greater);
        }
        if (dealCnt_greaterEqual != null) {
            c.andDealCntGreaterThanOrEqualTo(dealCnt_greaterEqual);
        }
        if (dealCnt_less != null) {
            c.andDealCntLessThan(dealCnt_less);
        }
        if (dealCnt_lessEqual != null) {
            c.andDealCntLessThanOrEqualTo(dealCnt_lessEqual);
        }
        if (dealCnt_in != null) {
            c.andDealCntIn(dealCnt_in);
        }
        if (dealCnt_notIn != null) {
            c.andDealCntNotIn(dealCnt_notIn);
        }
        if (dealCnt_between1 != null) {
            c.andDealCntBetween(dealCnt_between1, dealCnt_between2);
        }
        if (dealCnt_notBetween1 != null) {
            c.andDealCntNotBetween(dealCnt_notBetween1, dealCnt_notBetween2);
        }
        Date startTime_null = TypeCast.getDate(scheduleLogMap.get("startTime_null"));
        Date startTime_notNull = TypeCast.getDate(scheduleLogMap.get("startTime_notNull"));
        Date startTime = TypeCast.getDate(scheduleLogMap.get("startTime"));
        Date startTime_not = TypeCast.getDate(scheduleLogMap.get("startTime_not"));
        Date startTime_greater = TypeCast.getDate(scheduleLogMap.get("startTime_greater"));
        Date startTime_greaterEqual = TypeCast.getDate(scheduleLogMap.get("startTime_greaterEqual"));
        Date startTime_less = TypeCast.getDate(scheduleLogMap.get("startTime_less"));
        Date startTime_lessEqual = TypeCast.getDate(scheduleLogMap.get("startTime_lessEqual"));
        List<Date> startTime_in = TypeCast.getDateList(scheduleLogMap.get("startTime_in"));
        List<Date> startTime_notIn = TypeCast.getDateList(scheduleLogMap.get("startTime_notIn"));
        Date startTime_between1 = TypeCast.getDate(scheduleLogMap.get("startTime_between1"));
        Date startTime_between2 = TypeCast.getDate(scheduleLogMap.get("startTime_between2"));
        Date startTime_notBetween1 = TypeCast.getDate(scheduleLogMap.get("startTime_notBetween1"));
        Date startTime_notBetween2 = TypeCast.getDate(scheduleLogMap.get("startTime_notBetween2"));

        if (startTime_null != null) {
            c.andStartTimeIsNull();
        }
        if (startTime_notNull != null) {
            c.andStartTimeIsNotNull();
        }
        if (startTime != null) {
            c.andStartTimeEqualTo(startTime);
        }
        if (startTime_not != null) {
            c.andStartTimeNotEqualTo(startTime_not);
        }
        if (startTime_greater != null) {
            c.andStartTimeGreaterThan(startTime_greater);
        }
        if (startTime_greaterEqual != null) {
            c.andStartTimeGreaterThanOrEqualTo(startTime_greaterEqual);
        }
        if (startTime_less != null) {
            c.andStartTimeLessThan(startTime_less);
        }
        if (startTime_lessEqual != null) {
            c.andStartTimeLessThanOrEqualTo(startTime_lessEqual);
        }
        if (startTime_in != null) {
            c.andStartTimeIn(startTime_in);
        }
        if (startTime_notIn != null) {
            c.andStartTimeNotIn(startTime_notIn);
        }
        if (startTime_between1 != null) {
            c.andStartTimeBetween(startTime_between1, startTime_between2);
        }
        if (startTime_notBetween1 != null) {
            c.andStartTimeNotBetween(startTime_notBetween1, startTime_notBetween2);
        }
        Date endTime_null = TypeCast.getDate(scheduleLogMap.get("endTime_null"));
        Date endTime_notNull = TypeCast.getDate(scheduleLogMap.get("endTime_notNull"));
        Date endTime = TypeCast.getDate(scheduleLogMap.get("endTime"));
        Date endTime_not = TypeCast.getDate(scheduleLogMap.get("endTime_not"));
        Date endTime_greater = TypeCast.getDate(scheduleLogMap.get("endTime_greater"));
        Date endTime_greaterEqual = TypeCast.getDate(scheduleLogMap.get("endTime_greaterEqual"));
        Date endTime_less = TypeCast.getDate(scheduleLogMap.get("endTime_less"));
        Date endTime_lessEqual = TypeCast.getDate(scheduleLogMap.get("endTime_lessEqual"));
        List<Date> endTime_in = TypeCast.getDateList(scheduleLogMap.get("endTime_in"));
        List<Date> endTime_notIn = TypeCast.getDateList(scheduleLogMap.get("endTime_notIn"));
        Date endTime_between1 = TypeCast.getDate(scheduleLogMap.get("endTime_between1"));
        Date endTime_between2 = TypeCast.getDate(scheduleLogMap.get("endTime_between2"));
        Date endTime_notBetween1 = TypeCast.getDate(scheduleLogMap.get("endTime_notBetween1"));
        Date endTime_notBetween2 = TypeCast.getDate(scheduleLogMap.get("endTime_notBetween2"));

        if (endTime_null != null) {
            c.andEndTimeIsNull();
        }
        if (endTime_notNull != null) {
            c.andEndTimeIsNotNull();
        }
        if (endTime != null) {
            c.andEndTimeEqualTo(endTime);
        }
        if (endTime_not != null) {
            c.andEndTimeNotEqualTo(endTime_not);
        }
        if (endTime_greater != null) {
            c.andEndTimeGreaterThan(endTime_greater);
        }
        if (endTime_greaterEqual != null) {
            c.andEndTimeGreaterThanOrEqualTo(endTime_greaterEqual);
        }
        if (endTime_less != null) {
            c.andEndTimeLessThan(endTime_less);
        }
        if (endTime_lessEqual != null) {
            c.andEndTimeLessThanOrEqualTo(endTime_lessEqual);
        }
        if (endTime_in != null) {
            c.andEndTimeIn(endTime_in);
        }
        if (endTime_notIn != null) {
            c.andEndTimeNotIn(endTime_notIn);
        }
        if (endTime_between1 != null) {
            c.andEndTimeBetween(endTime_between1, endTime_between2);
        }
        if (endTime_notBetween1 != null) {
            c.andEndTimeNotBetween(endTime_notBetween1, endTime_notBetween2);
        }
        Date updateTime_null = TypeCast.getDate(scheduleLogMap.get("updateTime_null"));
        Date updateTime_notNull = TypeCast.getDate(scheduleLogMap.get("updateTime_notNull"));
        Date updateTime = TypeCast.getDate(scheduleLogMap.get("updateTime"));
        Date updateTime_not = TypeCast.getDate(scheduleLogMap.get("updateTime_not"));
        Date updateTime_greater = TypeCast.getDate(scheduleLogMap.get("updateTime_greater"));
        Date updateTime_greaterEqual = TypeCast.getDate(scheduleLogMap.get("updateTime_greaterEqual"));
        Date updateTime_less = TypeCast.getDate(scheduleLogMap.get("updateTime_less"));
        Date updateTime_lessEqual = TypeCast.getDate(scheduleLogMap.get("updateTime_lessEqual"));
        List<Date> updateTime_in = TypeCast.getDateList(scheduleLogMap.get("updateTime_in"));
        List<Date> updateTime_notIn = TypeCast.getDateList(scheduleLogMap.get("updateTime_notIn"));
        Date updateTime_between1 = TypeCast.getDate(scheduleLogMap.get("updateTime_between1"));
        Date updateTime_between2 = TypeCast.getDate(scheduleLogMap.get("updateTime_between2"));
        Date updateTime_notBetween1 = TypeCast.getDate(scheduleLogMap.get("updateTime_notBetween1"));
        Date updateTime_notBetween2 = TypeCast.getDate(scheduleLogMap.get("updateTime_notBetween2"));

        if (updateTime_null != null) {
            c.andUpdateTimeIsNull();
        }
        if (updateTime_notNull != null) {
            c.andUpdateTimeIsNotNull();
        }
        if (updateTime != null) {
            c.andUpdateTimeEqualTo(updateTime);
        }
        if (updateTime_not != null) {
            c.andUpdateTimeNotEqualTo(updateTime_not);
        }
        if (updateTime_greater != null) {
            c.andUpdateTimeGreaterThan(updateTime_greater);
        }
        if (updateTime_greaterEqual != null) {
            c.andUpdateTimeGreaterThanOrEqualTo(updateTime_greaterEqual);
        }
        if (updateTime_less != null) {
            c.andUpdateTimeLessThan(updateTime_less);
        }
        if (updateTime_lessEqual != null) {
            c.andUpdateTimeLessThanOrEqualTo(updateTime_lessEqual);
        }
        if (updateTime_in != null) {
            c.andUpdateTimeIn(updateTime_in);
        }
        if (updateTime_notIn != null) {
            c.andUpdateTimeNotIn(updateTime_notIn);
        }
        if (updateTime_between1 != null) {
            c.andUpdateTimeBetween(updateTime_between1, updateTime_between2);
        }
        if (updateTime_notBetween1 != null) {
            c.andUpdateTimeNotBetween(updateTime_notBetween1, updateTime_notBetween2);
        }
        if (scheduleLogMap.get("orderBy") != null) {
            scheduleLogEx.setOrderByClause((String) scheduleLogMap.get("orderBy"));
        }
        if (limitStart != null && limitOffset != null) {
            scheduleLogEx.setLimitStart(limitStart);
            scheduleLogEx.setLimitOffset(limitOffset);
        }

        return scheduleLogEx;
    }
}
